 /* Copyright 2018 JDCLOUD.COM

Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at

http:#www.apache.org/licenses/LICENSE-2.0

Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.

Video-on-Demand
视频点播相关接口

OpenAPI spec version: v1
Contact: 

NOTE: This class is auto generated by the jdcloud code generator program.
*/


#import <Foundation/Foundation.h>
#import <JDCloudOCSDKVod/VodExecutor.h>

@implementation VodClient

@synthesize userAgent = _userAgent;
@synthesize serviceName = _serviceName;
@synthesize version = _version;

-(void) addCustomerHeaderWithKey:(NSString*) key
                           value:(NSString*) value{
    if(![self customHeader])
    {
        self.customHeader = [[NSMutableDictionary alloc] init];
    }
    if(key && value)
    {
        [[self customHeader] setValue:value forKey:key];
    }
   
}

-(id)initWithGlobalConfig{
    if(![GlobalConfig credential])
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@"GlobalConfig credential not config" userInfo:nil];
        @throw e;
    }
    self.credential = [GlobalConfig credential];
    if(![GlobalConfig sdkEnvironment])
    {
        self.sdkEnvironment = [[SDKEnvironment alloc] initWithEndPoint:@"vod.jdcloud-api.com"];
    }else
    {
        self.sdkEnvironment = [GlobalConfig sdkEnvironment];
    }
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vod  v1";
    _serviceName = @"vod";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}

-(id)initWithCredential:(Credential*)credential
         sdkEnvironment:(SDKEnvironment*)sdkEnvironment
{
    if(!credential)
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@" credential can not null" userInfo:nil];
        @throw e;
    }else{
        self.credential = credential;
    }
    
    if(!sdkEnvironment)
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@" sdkEnvironment can not null" userInfo:nil];
        @throw e;
    }else{
        self.sdkEnvironment = sdkEnvironment;
    }
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vod  v1";
    _serviceName = @"vod";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}

-(id)initWithCredential:(Credential*)credential
{
    if(!credential)
    {
        NSException *e = [SDKArgumentNullException exceptionWithName:@"ArgumentNullException" reason:@" credential can not null" userInfo:nil];
        @throw e;
    }else{
        self.credential = credential;
    }
    if(![GlobalConfig sdkEnvironment])
    {
        self.sdkEnvironment = [[SDKEnvironment alloc] initWithEndPoint:@"vod.jdcloud-api.com"];
    }else
    {
        self.sdkEnvironment = [GlobalConfig sdkEnvironment];
    }
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vod  v1";
    _serviceName = @"vod";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}

-(id)init{
    self.httpRequestProtocol = @"https";
    _userAgent = @"JdCloudOCSdk 0.0.1 vod  v1";
    _serviceName = @"vod";
    _version = @"v1";
    self.contentType = @"application/json";
    return self;
}


/**
batchSubmitQualityDetectionJobs sync request
@param batchSubmitQualityDetectionJobsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `batchSubmitQualityDetectionJobsResponse` the request response data model
*/
-(NSDictionary*) batchSubmitQualityDetectionJobsSyncWithRequest:(VodBatchSubmitQualityDetectionJobsRequest*) batchSubmitQualityDetectionJobsRequest
{
VodBatchSubmitQualityDetectionJobsExecutor* excutor = [[VodBatchSubmitQualityDetectionJobsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:batchSubmitQualityDetectionJobsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchSubmitQualityDetectionJobsResponse* response = [[VodBatchSubmitQualityDetectionJobsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"batchSubmitQualityDetectionJobsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)batchSubmitQualityDetectionJobsAsyncWithRequest:(VodBatchSubmitQualityDetectionJobsRequest*) batchSubmitQualityDetectionJobsRequest
                       completionHandler:(void(^)(int statusCode,VodBatchSubmitQualityDetectionJobsResponse* _Nullable batchSubmitQualityDetectionJobsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodBatchSubmitQualityDetectionJobsExecutor* excutor = [[VodBatchSubmitQualityDetectionJobsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:batchSubmitQualityDetectionJobsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchSubmitQualityDetectionJobsResponse* response = [[VodBatchSubmitQualityDetectionJobsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteTranscodeTemplate sync request
@param deleteTranscodeTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteTranscodeTemplateResponse` the request response data model
*/
-(NSDictionary*) deleteTranscodeTemplateSyncWithRequest:(VodDeleteTranscodeTemplateRequest*) deleteTranscodeTemplateRequest
{
VodDeleteTranscodeTemplateExecutor* excutor = [[VodDeleteTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteTranscodeTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteTranscodeTemplateResponse* response = [[VodDeleteTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteTranscodeTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteTranscodeTemplateAsyncWithRequest:(VodDeleteTranscodeTemplateRequest*) deleteTranscodeTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteTranscodeTemplateResponse* _Nullable deleteTranscodeTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteTranscodeTemplateExecutor* excutor = [[VodDeleteTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteTranscodeTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteTranscodeTemplateResponse* response = [[VodDeleteTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
updateWatermark sync request
@param updateWatermarkRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `updateWatermarkResponse` the request response data model
*/
-(NSDictionary*) updateWatermarkSyncWithRequest:(VodUpdateWatermarkRequest*) updateWatermarkRequest
{
VodUpdateWatermarkExecutor* excutor = [[VodUpdateWatermarkExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:updateWatermarkRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateWatermarkResponse* response = [[VodUpdateWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"updateWatermarkResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)updateWatermarkAsyncWithRequest:(VodUpdateWatermarkRequest*) updateWatermarkRequest
                       completionHandler:(void(^)(int statusCode,VodUpdateWatermarkResponse* _Nullable updateWatermarkResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodUpdateWatermarkExecutor* excutor = [[VodUpdateWatermarkExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:updateWatermarkRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateWatermarkResponse* response = [[VodUpdateWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
listDomains sync request
@param listDomainsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `listDomainsResponse` the request response data model
*/
-(NSDictionary*) listDomainsSyncWithRequest:(VodListDomainsRequest*) listDomainsRequest
{
VodListDomainsExecutor* excutor = [[VodListDomainsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:listDomainsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListDomainsResponse* response = [[VodListDomainsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"listDomainsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)listDomainsAsyncWithRequest:(VodListDomainsRequest*) listDomainsRequest
                       completionHandler:(void(^)(int statusCode,VodListDomainsResponse* _Nullable listDomainsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodListDomainsExecutor* excutor = [[VodListDomainsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:listDomainsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListDomainsResponse* response = [[VodListDomainsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createVideoUploadTask sync request
@param createVideoUploadTaskRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createVideoUploadTaskResponse` the request response data model
*/
-(NSDictionary*) createVideoUploadTaskSyncWithRequest:(VodCreateVideoUploadTaskRequest*) createVideoUploadTaskRequest
{
VodCreateVideoUploadTaskExecutor* excutor = [[VodCreateVideoUploadTaskExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createVideoUploadTaskRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateVideoUploadTaskResponse* response = [[VodCreateVideoUploadTaskResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createVideoUploadTaskResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createVideoUploadTaskAsyncWithRequest:(VodCreateVideoUploadTaskRequest*) createVideoUploadTaskRequest
                       completionHandler:(void(^)(int statusCode,VodCreateVideoUploadTaskResponse* _Nullable createVideoUploadTaskResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodCreateVideoUploadTaskExecutor* excutor = [[VodCreateVideoUploadTaskExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createVideoUploadTaskRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateVideoUploadTaskResponse* response = [[VodCreateVideoUploadTaskResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getURLRule sync request
@param getURLRuleRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getURLRuleResponse` the request response data model
*/
-(NSDictionary*) getURLRuleSyncWithRequest:(VodGetURLRuleRequest*) getURLRuleRequest
{
VodGetURLRuleExecutor* excutor = [[VodGetURLRuleExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getURLRuleRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetURLRuleResponse* response = [[VodGetURLRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getURLRuleResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getURLRuleAsyncWithRequest:(VodGetURLRuleRequest*) getURLRuleRequest
                       completionHandler:(void(^)(int statusCode,VodGetURLRuleResponse* _Nullable getURLRuleResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetURLRuleExecutor* excutor = [[VodGetURLRuleExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getURLRuleRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetURLRuleResponse* response = [[VodGetURLRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
listHeaders sync request
@param listHeadersRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `listHeadersResponse` the request response data model
*/
-(NSDictionary*) listHeadersSyncWithRequest:(VodListHeadersRequest*) listHeadersRequest
{
VodListHeadersExecutor* excutor = [[VodListHeadersExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:listHeadersRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListHeadersResponse* response = [[VodListHeadersResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"listHeadersResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)listHeadersAsyncWithRequest:(VodListHeadersRequest*) listHeadersRequest
                       completionHandler:(void(^)(int statusCode,VodListHeadersResponse* _Nullable listHeadersResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodListHeadersExecutor* excutor = [[VodListHeadersExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:listHeadersRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListHeadersResponse* response = [[VodListHeadersResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
setURLRule sync request
@param setURLRuleRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `setURLRuleResponse` the request response data model
*/
-(NSDictionary*) setURLRuleSyncWithRequest:(VodSetURLRuleRequest*) setURLRuleRequest
{
VodSetURLRuleExecutor* excutor = [[VodSetURLRuleExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:setURLRuleRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetURLRuleResponse* response = [[VodSetURLRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"setURLRuleResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)setURLRuleAsyncWithRequest:(VodSetURLRuleRequest*) setURLRuleRequest
                       completionHandler:(void(^)(int statusCode,VodSetURLRuleResponse* _Nullable setURLRuleResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSetURLRuleExecutor* excutor = [[VodSetURLRuleExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:setURLRuleRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetURLRuleResponse* response = [[VodSetURLRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getCategoryWithChildren sync request
@param getCategoryWithChildrenRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getCategoryWithChildrenResponse` the request response data model
*/
-(NSDictionary*) getCategoryWithChildrenSyncWithRequest:(VodGetCategoryWithChildrenRequest*) getCategoryWithChildrenRequest
{
VodGetCategoryWithChildrenExecutor* excutor = [[VodGetCategoryWithChildrenExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getCategoryWithChildrenRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetCategoryWithChildrenResponse* response = [[VodGetCategoryWithChildrenResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getCategoryWithChildrenResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getCategoryWithChildrenAsyncWithRequest:(VodGetCategoryWithChildrenRequest*) getCategoryWithChildrenRequest
                       completionHandler:(void(^)(int statusCode,VodGetCategoryWithChildrenResponse* _Nullable getCategoryWithChildrenResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetCategoryWithChildrenExecutor* excutor = [[VodGetCategoryWithChildrenExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getCategoryWithChildrenRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetCategoryWithChildrenResponse* response = [[VodGetCategoryWithChildrenResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
listTranscodeTemplates sync request
@param listTranscodeTemplatesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `listTranscodeTemplatesResponse` the request response data model
*/
-(NSDictionary*) listTranscodeTemplatesSyncWithRequest:(VodListTranscodeTemplatesRequest*) listTranscodeTemplatesRequest
{
VodListTranscodeTemplatesExecutor* excutor = [[VodListTranscodeTemplatesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:listTranscodeTemplatesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListTranscodeTemplatesResponse* response = [[VodListTranscodeTemplatesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"listTranscodeTemplatesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)listTranscodeTemplatesAsyncWithRequest:(VodListTranscodeTemplatesRequest*) listTranscodeTemplatesRequest
                       completionHandler:(void(^)(int statusCode,VodListTranscodeTemplatesResponse* _Nullable listTranscodeTemplatesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodListTranscodeTemplatesExecutor* excutor = [[VodListTranscodeTemplatesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:listTranscodeTemplatesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListTranscodeTemplatesResponse* response = [[VodListTranscodeTemplatesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getCategory sync request
@param getCategoryRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getCategoryResponse` the request response data model
*/
-(NSDictionary*) getCategorySyncWithRequest:(VodGetCategoryRequest*) getCategoryRequest
{
VodGetCategoryExecutor* excutor = [[VodGetCategoryExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getCategoryRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetCategoryResponse* response = [[VodGetCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getCategoryResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getCategoryAsyncWithRequest:(VodGetCategoryRequest*) getCategoryRequest
                       completionHandler:(void(^)(int statusCode,VodGetCategoryResponse* _Nullable getCategoryResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetCategoryExecutor* excutor = [[VodGetCategoryExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getCategoryRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetCategoryResponse* response = [[VodGetCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createDomain sync request
@param createDomainRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createDomainResponse` the request response data model
*/
-(NSDictionary*) createDomainSyncWithRequest:(VodCreateDomainRequest*) createDomainRequest
{
VodCreateDomainExecutor* excutor = [[VodCreateDomainExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createDomainRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateDomainResponse* response = [[VodCreateDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createDomainResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createDomainAsyncWithRequest:(VodCreateDomainRequest*) createDomainRequest
                       completionHandler:(void(^)(int statusCode,VodCreateDomainResponse* _Nullable createDomainResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodCreateDomainExecutor* excutor = [[VodCreateDomainExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createDomainRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateDomainResponse* response = [[VodCreateDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteWatermark sync request
@param deleteWatermarkRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteWatermarkResponse` the request response data model
*/
-(NSDictionary*) deleteWatermarkSyncWithRequest:(VodDeleteWatermarkRequest*) deleteWatermarkRequest
{
VodDeleteWatermarkExecutor* excutor = [[VodDeleteWatermarkExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteWatermarkRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteWatermarkResponse* response = [[VodDeleteWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteWatermarkResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteWatermarkAsyncWithRequest:(VodDeleteWatermarkRequest*) deleteWatermarkRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteWatermarkResponse* _Nullable deleteWatermarkResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteWatermarkExecutor* excutor = [[VodDeleteWatermarkExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteWatermarkRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteWatermarkResponse* response = [[VodDeleteWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
submitTranscodeJob sync request
@param submitTranscodeJobRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `submitTranscodeJobResponse` the request response data model
*/
-(NSDictionary*) submitTranscodeJobSyncWithRequest:(VodSubmitTranscodeJobRequest*) submitTranscodeJobRequest
{
VodSubmitTranscodeJobExecutor* excutor = [[VodSubmitTranscodeJobExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:submitTranscodeJobRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSubmitTranscodeJobResponse* response = [[VodSubmitTranscodeJobResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"submitTranscodeJobResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)submitTranscodeJobAsyncWithRequest:(VodSubmitTranscodeJobRequest*) submitTranscodeJobRequest
                       completionHandler:(void(^)(int statusCode,VodSubmitTranscodeJobResponse* _Nullable submitTranscodeJobResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSubmitTranscodeJobExecutor* excutor = [[VodSubmitTranscodeJobExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:submitTranscodeJobRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSubmitTranscodeJobResponse* response = [[VodSubmitTranscodeJobResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
updateTranscodeTemplate sync request
@param updateTranscodeTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `updateTranscodeTemplateResponse` the request response data model
*/
-(NSDictionary*) updateTranscodeTemplateSyncWithRequest:(VodUpdateTranscodeTemplateRequest*) updateTranscodeTemplateRequest
{
VodUpdateTranscodeTemplateExecutor* excutor = [[VodUpdateTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:updateTranscodeTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateTranscodeTemplateResponse* response = [[VodUpdateTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"updateTranscodeTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)updateTranscodeTemplateAsyncWithRequest:(VodUpdateTranscodeTemplateRequest*) updateTranscodeTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodUpdateTranscodeTemplateResponse* _Nullable updateTranscodeTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodUpdateTranscodeTemplateExecutor* excutor = [[VodUpdateTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:updateTranscodeTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateTranscodeTemplateResponse* response = [[VodUpdateTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
listQualityDetectionTemplates sync request
@param listQualityDetectionTemplatesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `listQualityDetectionTemplatesResponse` the request response data model
*/
-(NSDictionary*) listQualityDetectionTemplatesSyncWithRequest:(VodListQualityDetectionTemplatesRequest*) listQualityDetectionTemplatesRequest
{
VodListQualityDetectionTemplatesExecutor* excutor = [[VodListQualityDetectionTemplatesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:listQualityDetectionTemplatesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListQualityDetectionTemplatesResponse* response = [[VodListQualityDetectionTemplatesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"listQualityDetectionTemplatesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)listQualityDetectionTemplatesAsyncWithRequest:(VodListQualityDetectionTemplatesRequest*) listQualityDetectionTemplatesRequest
                       completionHandler:(void(^)(int statusCode,VodListQualityDetectionTemplatesResponse* _Nullable listQualityDetectionTemplatesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodListQualityDetectionTemplatesExecutor* excutor = [[VodListQualityDetectionTemplatesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:listQualityDetectionTemplatesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListQualityDetectionTemplatesResponse* response = [[VodListQualityDetectionTemplatesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
batchUpdateVideos sync request
@param batchUpdateVideosRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `batchUpdateVideosResponse` the request response data model
*/
-(NSDictionary*) batchUpdateVideosSyncWithRequest:(VodBatchUpdateVideosRequest*) batchUpdateVideosRequest
{
VodBatchUpdateVideosExecutor* excutor = [[VodBatchUpdateVideosExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:batchUpdateVideosRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchUpdateVideosResponse* response = [[VodBatchUpdateVideosResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"batchUpdateVideosResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)batchUpdateVideosAsyncWithRequest:(VodBatchUpdateVideosRequest*) batchUpdateVideosRequest
                       completionHandler:(void(^)(int statusCode,VodBatchUpdateVideosResponse* _Nullable batchUpdateVideosResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodBatchUpdateVideosExecutor* excutor = [[VodBatchUpdateVideosExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:batchUpdateVideosRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchUpdateVideosResponse* response = [[VodBatchUpdateVideosResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createImageUploadTask sync request
@param createImageUploadTaskRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createImageUploadTaskResponse` the request response data model
*/
-(NSDictionary*) createImageUploadTaskSyncWithRequest:(VodCreateImageUploadTaskRequest*) createImageUploadTaskRequest
{
VodCreateImageUploadTaskExecutor* excutor = [[VodCreateImageUploadTaskExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createImageUploadTaskRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateImageUploadTaskResponse* response = [[VodCreateImageUploadTaskResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createImageUploadTaskResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createImageUploadTaskAsyncWithRequest:(VodCreateImageUploadTaskRequest*) createImageUploadTaskRequest
                       completionHandler:(void(^)(int statusCode,VodCreateImageUploadTaskResponse* _Nullable createImageUploadTaskResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodCreateImageUploadTaskExecutor* excutor = [[VodCreateImageUploadTaskExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createImageUploadTaskRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateImageUploadTaskResponse* response = [[VodCreateImageUploadTaskResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
updateQualityDetectionTemplate sync request
@param updateQualityDetectionTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `updateQualityDetectionTemplateResponse` the request response data model
*/
-(NSDictionary*) updateQualityDetectionTemplateSyncWithRequest:(VodUpdateQualityDetectionTemplateRequest*) updateQualityDetectionTemplateRequest
{
VodUpdateQualityDetectionTemplateExecutor* excutor = [[VodUpdateQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:updateQualityDetectionTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateQualityDetectionTemplateResponse* response = [[VodUpdateQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"updateQualityDetectionTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)updateQualityDetectionTemplateAsyncWithRequest:(VodUpdateQualityDetectionTemplateRequest*) updateQualityDetectionTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodUpdateQualityDetectionTemplateResponse* _Nullable updateQualityDetectionTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodUpdateQualityDetectionTemplateExecutor* excutor = [[VodUpdateQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:updateQualityDetectionTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateQualityDetectionTemplateResponse* response = [[VodUpdateQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getDomain sync request
@param getDomainRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getDomainResponse` the request response data model
*/
-(NSDictionary*) getDomainSyncWithRequest:(VodGetDomainRequest*) getDomainRequest
{
VodGetDomainExecutor* excutor = [[VodGetDomainExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getDomainRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetDomainResponse* response = [[VodGetDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getDomainResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getDomainAsyncWithRequest:(VodGetDomainRequest*) getDomainRequest
                       completionHandler:(void(^)(int statusCode,VodGetDomainResponse* _Nullable getDomainResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetDomainExecutor* excutor = [[VodGetDomainExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getDomainRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetDomainResponse* response = [[VodGetDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getWatermark sync request
@param getWatermarkRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getWatermarkResponse` the request response data model
*/
-(NSDictionary*) getWatermarkSyncWithRequest:(VodGetWatermarkRequest*) getWatermarkRequest
{
VodGetWatermarkExecutor* excutor = [[VodGetWatermarkExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getWatermarkRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetWatermarkResponse* response = [[VodGetWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getWatermarkResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getWatermarkAsyncWithRequest:(VodGetWatermarkRequest*) getWatermarkRequest
                       completionHandler:(void(^)(int statusCode,VodGetWatermarkResponse* _Nullable getWatermarkResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetWatermarkExecutor* excutor = [[VodGetWatermarkExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getWatermarkRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetWatermarkResponse* response = [[VodGetWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteVideoStreams sync request
@param deleteVideoStreamsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteVideoStreamsResponse` the request response data model
*/
-(NSDictionary*) deleteVideoStreamsSyncWithRequest:(VodDeleteVideoStreamsRequest*) deleteVideoStreamsRequest
{
VodDeleteVideoStreamsExecutor* excutor = [[VodDeleteVideoStreamsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteVideoStreamsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteVideoStreamsResponse* response = [[VodDeleteVideoStreamsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteVideoStreamsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteVideoStreamsAsyncWithRequest:(VodDeleteVideoStreamsRequest*) deleteVideoStreamsRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteVideoStreamsResponse* _Nullable deleteVideoStreamsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteVideoStreamsExecutor* excutor = [[VodDeleteVideoStreamsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteVideoStreamsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteVideoStreamsResponse* response = [[VodDeleteVideoStreamsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
batchSubmitTranscodeJobs sync request
@param batchSubmitTranscodeJobsRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `batchSubmitTranscodeJobsResponse` the request response data model
*/
-(NSDictionary*) batchSubmitTranscodeJobsSyncWithRequest:(VodBatchSubmitTranscodeJobsRequest*) batchSubmitTranscodeJobsRequest
{
VodBatchSubmitTranscodeJobsExecutor* excutor = [[VodBatchSubmitTranscodeJobsExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:batchSubmitTranscodeJobsRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchSubmitTranscodeJobsResponse* response = [[VodBatchSubmitTranscodeJobsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"batchSubmitTranscodeJobsResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)batchSubmitTranscodeJobsAsyncWithRequest:(VodBatchSubmitTranscodeJobsRequest*) batchSubmitTranscodeJobsRequest
                       completionHandler:(void(^)(int statusCode,VodBatchSubmitTranscodeJobsResponse* _Nullable batchSubmitTranscodeJobsResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodBatchSubmitTranscodeJobsExecutor* excutor = [[VodBatchSubmitTranscodeJobsExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:batchSubmitTranscodeJobsRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchSubmitTranscodeJobsResponse* response = [[VodBatchSubmitTranscodeJobsResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
setIPRule sync request
@param setIPRuleRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `setIPRuleResponse` the request response data model
*/
-(NSDictionary*) setIPRuleSyncWithRequest:(VodSetIPRuleRequest*) setIPRuleRequest
{
VodSetIPRuleExecutor* excutor = [[VodSetIPRuleExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:setIPRuleRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetIPRuleResponse* response = [[VodSetIPRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"setIPRuleResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)setIPRuleAsyncWithRequest:(VodSetIPRuleRequest*) setIPRuleRequest
                       completionHandler:(void(^)(int statusCode,VodSetIPRuleResponse* _Nullable setIPRuleResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSetIPRuleExecutor* excutor = [[VodSetIPRuleExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:setIPRuleRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetIPRuleResponse* response = [[VodSetIPRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
updateVideo sync request
@param updateVideoRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `updateVideoResponse` the request response data model
*/
-(NSDictionary*) updateVideoSyncWithRequest:(VodUpdateVideoRequest*) updateVideoRequest
{
VodUpdateVideoExecutor* excutor = [[VodUpdateVideoExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:updateVideoRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateVideoResponse* response = [[VodUpdateVideoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"updateVideoResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)updateVideoAsyncWithRequest:(VodUpdateVideoRequest*) updateVideoRequest
                       completionHandler:(void(^)(int statusCode,VodUpdateVideoResponse* _Nullable updateVideoResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodUpdateVideoExecutor* excutor = [[VodUpdateVideoExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:updateVideoRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateVideoResponse* response = [[VodUpdateVideoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
setDefaultDomain sync request
@param setDefaultDomainRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `setDefaultDomainResponse` the request response data model
*/
-(NSDictionary*) setDefaultDomainSyncWithRequest:(VodSetDefaultDomainRequest*) setDefaultDomainRequest
{
VodSetDefaultDomainExecutor* excutor = [[VodSetDefaultDomainExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:setDefaultDomainRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetDefaultDomainResponse* response = [[VodSetDefaultDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"setDefaultDomainResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)setDefaultDomainAsyncWithRequest:(VodSetDefaultDomainRequest*) setDefaultDomainRequest
                       completionHandler:(void(^)(int statusCode,VodSetDefaultDomainResponse* _Nullable setDefaultDomainResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSetDefaultDomainExecutor* excutor = [[VodSetDefaultDomainExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:setDefaultDomainRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetDefaultDomainResponse* response = [[VodSetDefaultDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getTranscodeTemplate sync request
@param getTranscodeTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getTranscodeTemplateResponse` the request response data model
*/
-(NSDictionary*) getTranscodeTemplateSyncWithRequest:(VodGetTranscodeTemplateRequest*) getTranscodeTemplateRequest
{
VodGetTranscodeTemplateExecutor* excutor = [[VodGetTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getTranscodeTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetTranscodeTemplateResponse* response = [[VodGetTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getTranscodeTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getTranscodeTemplateAsyncWithRequest:(VodGetTranscodeTemplateRequest*) getTranscodeTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodGetTranscodeTemplateResponse* _Nullable getTranscodeTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetTranscodeTemplateExecutor* excutor = [[VodGetTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getTranscodeTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetTranscodeTemplateResponse* response = [[VodGetTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteCategory sync request
@param deleteCategoryRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteCategoryResponse` the request response data model
*/
-(NSDictionary*) deleteCategorySyncWithRequest:(VodDeleteCategoryRequest*) deleteCategoryRequest
{
VodDeleteCategoryExecutor* excutor = [[VodDeleteCategoryExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteCategoryRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteCategoryResponse* response = [[VodDeleteCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteCategoryResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteCategoryAsyncWithRequest:(VodDeleteCategoryRequest*) deleteCategoryRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteCategoryResponse* _Nullable deleteCategoryResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteCategoryExecutor* excutor = [[VodDeleteCategoryExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteCategoryRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteCategoryResponse* response = [[VodDeleteCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getVideoPlayInfo sync request
@param getVideoPlayInfoRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getVideoPlayInfoResponse` the request response data model
*/
-(NSDictionary*) getVideoPlayInfoSyncWithRequest:(VodGetVideoPlayInfoRequest*) getVideoPlayInfoRequest
{
VodGetVideoPlayInfoExecutor* excutor = [[VodGetVideoPlayInfoExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getVideoPlayInfoRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetVideoPlayInfoResponse* response = [[VodGetVideoPlayInfoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getVideoPlayInfoResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getVideoPlayInfoAsyncWithRequest:(VodGetVideoPlayInfoRequest*) getVideoPlayInfoRequest
                       completionHandler:(void(^)(int statusCode,VodGetVideoPlayInfoResponse* _Nullable getVideoPlayInfoResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetVideoPlayInfoExecutor* excutor = [[VodGetVideoPlayInfoExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getVideoPlayInfoRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetVideoPlayInfoResponse* response = [[VodGetVideoPlayInfoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteHeader sync request
@param deleteHeaderRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteHeaderResponse` the request response data model
*/
-(NSDictionary*) deleteHeaderSyncWithRequest:(VodDeleteHeaderRequest*) deleteHeaderRequest
{
VodDeleteHeaderExecutor* excutor = [[VodDeleteHeaderExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteHeaderRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteHeaderResponse* response = [[VodDeleteHeaderResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteHeaderResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteHeaderAsyncWithRequest:(VodDeleteHeaderRequest*) deleteHeaderRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteHeaderResponse* _Nullable deleteHeaderResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteHeaderExecutor* excutor = [[VodDeleteHeaderExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteHeaderRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteHeaderResponse* response = [[VodDeleteHeaderResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
updateCategory sync request
@param updateCategoryRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `updateCategoryResponse` the request response data model
*/
-(NSDictionary*) updateCategorySyncWithRequest:(VodUpdateCategoryRequest*) updateCategoryRequest
{
VodUpdateCategoryExecutor* excutor = [[VodUpdateCategoryExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:updateCategoryRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateCategoryResponse* response = [[VodUpdateCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"updateCategoryResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)updateCategoryAsyncWithRequest:(VodUpdateCategoryRequest*) updateCategoryRequest
                       completionHandler:(void(^)(int statusCode,VodUpdateCategoryResponse* _Nullable updateCategoryResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodUpdateCategoryExecutor* excutor = [[VodUpdateCategoryExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:updateCategoryRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodUpdateCategoryResponse* response = [[VodUpdateCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
setRefererRule sync request
@param setRefererRuleRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `setRefererRuleResponse` the request response data model
*/
-(NSDictionary*) setRefererRuleSyncWithRequest:(VodSetRefererRuleRequest*) setRefererRuleRequest
{
VodSetRefererRuleExecutor* excutor = [[VodSetRefererRuleExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:setRefererRuleRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetRefererRuleResponse* response = [[VodSetRefererRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"setRefererRuleResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)setRefererRuleAsyncWithRequest:(VodSetRefererRuleRequest*) setRefererRuleRequest
                       completionHandler:(void(^)(int statusCode,VodSetRefererRuleResponse* _Nullable setRefererRuleResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSetRefererRuleExecutor* excutor = [[VodSetRefererRuleExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:setRefererRuleRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetRefererRuleResponse* response = [[VodSetRefererRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createQualityDetectionTemplate sync request
@param createQualityDetectionTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createQualityDetectionTemplateResponse` the request response data model
*/
-(NSDictionary*) createQualityDetectionTemplateSyncWithRequest:(VodCreateQualityDetectionTemplateRequest*) createQualityDetectionTemplateRequest
{
VodCreateQualityDetectionTemplateExecutor* excutor = [[VodCreateQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createQualityDetectionTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateQualityDetectionTemplateResponse* response = [[VodCreateQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createQualityDetectionTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createQualityDetectionTemplateAsyncWithRequest:(VodCreateQualityDetectionTemplateRequest*) createQualityDetectionTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodCreateQualityDetectionTemplateResponse* _Nullable createQualityDetectionTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodCreateQualityDetectionTemplateExecutor* excutor = [[VodCreateQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createQualityDetectionTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateQualityDetectionTemplateResponse* response = [[VodCreateQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getRefererRule sync request
@param getRefererRuleRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getRefererRuleResponse` the request response data model
*/
-(NSDictionary*) getRefererRuleSyncWithRequest:(VodGetRefererRuleRequest*) getRefererRuleRequest
{
VodGetRefererRuleExecutor* excutor = [[VodGetRefererRuleExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getRefererRuleRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetRefererRuleResponse* response = [[VodGetRefererRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getRefererRuleResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getRefererRuleAsyncWithRequest:(VodGetRefererRuleRequest*) getRefererRuleRequest
                       completionHandler:(void(^)(int statusCode,VodGetRefererRuleResponse* _Nullable getRefererRuleResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetRefererRuleExecutor* excutor = [[VodGetRefererRuleExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getRefererRuleRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetRefererRuleResponse* response = [[VodGetRefererRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getQualityDetectionTemplate sync request
@param getQualityDetectionTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getQualityDetectionTemplateResponse` the request response data model
*/
-(NSDictionary*) getQualityDetectionTemplateSyncWithRequest:(VodGetQualityDetectionTemplateRequest*) getQualityDetectionTemplateRequest
{
VodGetQualityDetectionTemplateExecutor* excutor = [[VodGetQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getQualityDetectionTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetQualityDetectionTemplateResponse* response = [[VodGetQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getQualityDetectionTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getQualityDetectionTemplateAsyncWithRequest:(VodGetQualityDetectionTemplateRequest*) getQualityDetectionTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodGetQualityDetectionTemplateResponse* _Nullable getQualityDetectionTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetQualityDetectionTemplateExecutor* excutor = [[VodGetQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getQualityDetectionTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetQualityDetectionTemplateResponse* response = [[VodGetQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteDomain sync request
@param deleteDomainRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteDomainResponse` the request response data model
*/
-(NSDictionary*) deleteDomainSyncWithRequest:(VodDeleteDomainRequest*) deleteDomainRequest
{
VodDeleteDomainExecutor* excutor = [[VodDeleteDomainExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteDomainRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteDomainResponse* response = [[VodDeleteDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteDomainResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteDomainAsyncWithRequest:(VodDeleteDomainRequest*) deleteDomainRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteDomainResponse* _Nullable deleteDomainResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteDomainExecutor* excutor = [[VodDeleteDomainExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteDomainRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteDomainResponse* response = [[VodDeleteDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createCategory sync request
@param createCategoryRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createCategoryResponse` the request response data model
*/
-(NSDictionary*) createCategorySyncWithRequest:(VodCreateCategoryRequest*) createCategoryRequest
{
VodCreateCategoryExecutor* excutor = [[VodCreateCategoryExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createCategoryRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateCategoryResponse* response = [[VodCreateCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createCategoryResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createCategoryAsyncWithRequest:(VodCreateCategoryRequest*) createCategoryRequest
                       completionHandler:(void(^)(int statusCode,VodCreateCategoryResponse* _Nullable createCategoryResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodCreateCategoryExecutor* excutor = [[VodCreateCategoryExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createCategoryRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateCategoryResponse* response = [[VodCreateCategoryResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
listWatermarks sync request
@param listWatermarksRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `listWatermarksResponse` the request response data model
*/
-(NSDictionary*) listWatermarksSyncWithRequest:(VodListWatermarksRequest*) listWatermarksRequest
{
VodListWatermarksExecutor* excutor = [[VodListWatermarksExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:listWatermarksRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListWatermarksResponse* response = [[VodListWatermarksResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"listWatermarksResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)listWatermarksAsyncWithRequest:(VodListWatermarksRequest*) listWatermarksRequest
                       completionHandler:(void(^)(int statusCode,VodListWatermarksResponse* _Nullable listWatermarksResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodListWatermarksExecutor* excutor = [[VodListWatermarksExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:listWatermarksRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListWatermarksResponse* response = [[VodListWatermarksResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getHttpSsl sync request
@param getHttpSslRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getHttpSslResponse` the request response data model
*/
-(NSDictionary*) getHttpSslSyncWithRequest:(VodGetHttpSslRequest*) getHttpSslRequest
{
VodGetHttpSslExecutor* excutor = [[VodGetHttpSslExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getHttpSslRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetHttpSslResponse* response = [[VodGetHttpSslResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getHttpSslResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getHttpSslAsyncWithRequest:(VodGetHttpSslRequest*) getHttpSslRequest
                       completionHandler:(void(^)(int statusCode,VodGetHttpSslResponse* _Nullable getHttpSslResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetHttpSslExecutor* excutor = [[VodGetHttpSslExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getHttpSslRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetHttpSslResponse* response = [[VodGetHttpSslResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
setHeader sync request
@param setHeaderRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `setHeaderResponse` the request response data model
*/
-(NSDictionary*) setHeaderSyncWithRequest:(VodSetHeaderRequest*) setHeaderRequest
{
VodSetHeaderExecutor* excutor = [[VodSetHeaderExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:setHeaderRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetHeaderResponse* response = [[VodSetHeaderResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"setHeaderResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)setHeaderAsyncWithRequest:(VodSetHeaderRequest*) setHeaderRequest
                       completionHandler:(void(^)(int statusCode,VodSetHeaderResponse* _Nullable setHeaderResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSetHeaderExecutor* excutor = [[VodSetHeaderExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:setHeaderRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetHeaderResponse* response = [[VodSetHeaderResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
refreshVideoUploadTask sync request
@param refreshVideoUploadTaskRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `refreshVideoUploadTaskResponse` the request response data model
*/
-(NSDictionary*) refreshVideoUploadTaskSyncWithRequest:(VodRefreshVideoUploadTaskRequest*) refreshVideoUploadTaskRequest
{
VodRefreshVideoUploadTaskExecutor* excutor = [[VodRefreshVideoUploadTaskExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:refreshVideoUploadTaskRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodRefreshVideoUploadTaskResponse* response = [[VodRefreshVideoUploadTaskResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"refreshVideoUploadTaskResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)refreshVideoUploadTaskAsyncWithRequest:(VodRefreshVideoUploadTaskRequest*) refreshVideoUploadTaskRequest
                       completionHandler:(void(^)(int statusCode,VodRefreshVideoUploadTaskResponse* _Nullable refreshVideoUploadTaskResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodRefreshVideoUploadTaskExecutor* excutor = [[VodRefreshVideoUploadTaskExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:refreshVideoUploadTaskRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodRefreshVideoUploadTaskResponse* response = [[VodRefreshVideoUploadTaskResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getVideo sync request
@param getVideoRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getVideoResponse` the request response data model
*/
-(NSDictionary*) getVideoSyncWithRequest:(VodGetVideoRequest*) getVideoRequest
{
VodGetVideoExecutor* excutor = [[VodGetVideoExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getVideoRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetVideoResponse* response = [[VodGetVideoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getVideoResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getVideoAsyncWithRequest:(VodGetVideoRequest*) getVideoRequest
                       completionHandler:(void(^)(int statusCode,VodGetVideoResponse* _Nullable getVideoResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetVideoExecutor* excutor = [[VodGetVideoExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getVideoRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetVideoResponse* response = [[VodGetVideoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
listVideos sync request
@param listVideosRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `listVideosResponse` the request response data model
*/
-(NSDictionary*) listVideosSyncWithRequest:(VodListVideosRequest*) listVideosRequest
{
VodListVideosExecutor* excutor = [[VodListVideosExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:listVideosRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListVideosResponse* response = [[VodListVideosResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"listVideosResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)listVideosAsyncWithRequest:(VodListVideosRequest*) listVideosRequest
                       completionHandler:(void(^)(int statusCode,VodListVideosResponse* _Nullable listVideosResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodListVideosExecutor* excutor = [[VodListVideosExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:listVideosRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListVideosResponse* response = [[VodListVideosResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createWatermark sync request
@param createWatermarkRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createWatermarkResponse` the request response data model
*/
-(NSDictionary*) createWatermarkSyncWithRequest:(VodCreateWatermarkRequest*) createWatermarkRequest
{
VodCreateWatermarkExecutor* excutor = [[VodCreateWatermarkExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createWatermarkRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateWatermarkResponse* response = [[VodCreateWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createWatermarkResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createWatermarkAsyncWithRequest:(VodCreateWatermarkRequest*) createWatermarkRequest
                       completionHandler:(void(^)(int statusCode,VodCreateWatermarkResponse* _Nullable createWatermarkResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodCreateWatermarkExecutor* excutor = [[VodCreateWatermarkExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createWatermarkRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateWatermarkResponse* response = [[VodCreateWatermarkResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteVideo sync request
@param deleteVideoRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteVideoResponse` the request response data model
*/
-(NSDictionary*) deleteVideoSyncWithRequest:(VodDeleteVideoRequest*) deleteVideoRequest
{
VodDeleteVideoExecutor* excutor = [[VodDeleteVideoExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteVideoRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteVideoResponse* response = [[VodDeleteVideoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteVideoResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteVideoAsyncWithRequest:(VodDeleteVideoRequest*) deleteVideoRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteVideoResponse* _Nullable deleteVideoResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteVideoExecutor* excutor = [[VodDeleteVideoExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteVideoRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteVideoResponse* response = [[VodDeleteVideoResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
submitQualityDetectionJob sync request
@param submitQualityDetectionJobRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `submitQualityDetectionJobResponse` the request response data model
*/
-(NSDictionary*) submitQualityDetectionJobSyncWithRequest:(VodSubmitQualityDetectionJobRequest*) submitQualityDetectionJobRequest
{
VodSubmitQualityDetectionJobExecutor* excutor = [[VodSubmitQualityDetectionJobExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:submitQualityDetectionJobRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSubmitQualityDetectionJobResponse* response = [[VodSubmitQualityDetectionJobResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"submitQualityDetectionJobResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)submitQualityDetectionJobAsyncWithRequest:(VodSubmitQualityDetectionJobRequest*) submitQualityDetectionJobRequest
                       completionHandler:(void(^)(int statusCode,VodSubmitQualityDetectionJobResponse* _Nullable submitQualityDetectionJobResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSubmitQualityDetectionJobExecutor* excutor = [[VodSubmitQualityDetectionJobExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:submitQualityDetectionJobRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSubmitQualityDetectionJobResponse* response = [[VodSubmitQualityDetectionJobResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
getIPRule sync request
@param getIPRuleRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `getIPRuleResponse` the request response data model
*/
-(NSDictionary*) getIPRuleSyncWithRequest:(VodGetIPRuleRequest*) getIPRuleRequest
{
VodGetIPRuleExecutor* excutor = [[VodGetIPRuleExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:getIPRuleRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetIPRuleResponse* response = [[VodGetIPRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"getIPRuleResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)getIPRuleAsyncWithRequest:(VodGetIPRuleRequest*) getIPRuleRequest
                       completionHandler:(void(^)(int statusCode,VodGetIPRuleResponse* _Nullable getIPRuleResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodGetIPRuleExecutor* excutor = [[VodGetIPRuleExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:getIPRuleRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodGetIPRuleResponse* response = [[VodGetIPRuleResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
enableDomain sync request
@param enableDomainRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `enableDomainResponse` the request response data model
*/
-(NSDictionary*) enableDomainSyncWithRequest:(VodEnableDomainRequest*) enableDomainRequest
{
VodEnableDomainExecutor* excutor = [[VodEnableDomainExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:enableDomainRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodEnableDomainResponse* response = [[VodEnableDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"enableDomainResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)enableDomainAsyncWithRequest:(VodEnableDomainRequest*) enableDomainRequest
                       completionHandler:(void(^)(int statusCode,VodEnableDomainResponse* _Nullable enableDomainResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodEnableDomainExecutor* excutor = [[VodEnableDomainExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:enableDomainRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodEnableDomainResponse* response = [[VodEnableDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
setHttpSsl sync request
@param setHttpSslRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `setHttpSslResponse` the request response data model
*/
-(NSDictionary*) setHttpSslSyncWithRequest:(VodSetHttpSslRequest*) setHttpSslRequest
{
VodSetHttpSslExecutor* excutor = [[VodSetHttpSslExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:setHttpSslRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetHttpSslResponse* response = [[VodSetHttpSslResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"setHttpSslResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)setHttpSslAsyncWithRequest:(VodSetHttpSslRequest*) setHttpSslRequest
                       completionHandler:(void(^)(int statusCode,VodSetHttpSslResponse* _Nullable setHttpSslResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodSetHttpSslExecutor* excutor = [[VodSetHttpSslExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:setHttpSslRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodSetHttpSslResponse* response = [[VodSetHttpSslResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
createTranscodeTemplate sync request
@param createTranscodeTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `createTranscodeTemplateResponse` the request response data model
*/
-(NSDictionary*) createTranscodeTemplateSyncWithRequest:(VodCreateTranscodeTemplateRequest*) createTranscodeTemplateRequest
{
VodCreateTranscodeTemplateExecutor* excutor = [[VodCreateTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:createTranscodeTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateTranscodeTemplateResponse* response = [[VodCreateTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"createTranscodeTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)createTranscodeTemplateAsyncWithRequest:(VodCreateTranscodeTemplateRequest*) createTranscodeTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodCreateTranscodeTemplateResponse* _Nullable createTranscodeTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodCreateTranscodeTemplateExecutor* excutor = [[VodCreateTranscodeTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:createTranscodeTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodCreateTranscodeTemplateResponse* response = [[VodCreateTranscodeTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
listCategories sync request
@param listCategoriesRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `listCategoriesResponse` the request response data model
*/
-(NSDictionary*) listCategoriesSyncWithRequest:(VodListCategoriesRequest*) listCategoriesRequest
{
VodListCategoriesExecutor* excutor = [[VodListCategoriesExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:listCategoriesRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListCategoriesResponse* response = [[VodListCategoriesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"listCategoriesResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)listCategoriesAsyncWithRequest:(VodListCategoriesRequest*) listCategoriesRequest
                       completionHandler:(void(^)(int statusCode,VodListCategoriesResponse* _Nullable listCategoriesResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodListCategoriesExecutor* excutor = [[VodListCategoriesExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:listCategoriesRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodListCategoriesResponse* response = [[VodListCategoriesResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
batchDeleteVideos sync request
@param batchDeleteVideosRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `batchDeleteVideosResponse` the request response data model
*/
-(NSDictionary*) batchDeleteVideosSyncWithRequest:(VodBatchDeleteVideosRequest*) batchDeleteVideosRequest
{
VodBatchDeleteVideosExecutor* excutor = [[VodBatchDeleteVideosExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:batchDeleteVideosRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchDeleteVideosResponse* response = [[VodBatchDeleteVideosResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"batchDeleteVideosResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)batchDeleteVideosAsyncWithRequest:(VodBatchDeleteVideosRequest*) batchDeleteVideosRequest
                       completionHandler:(void(^)(int statusCode,VodBatchDeleteVideosResponse* _Nullable batchDeleteVideosResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodBatchDeleteVideosExecutor* excutor = [[VodBatchDeleteVideosExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:batchDeleteVideosRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodBatchDeleteVideosResponse* response = [[VodBatchDeleteVideosResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
disableDomain sync request
@param disableDomainRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `disableDomainResponse` the request response data model
*/
-(NSDictionary*) disableDomainSyncWithRequest:(VodDisableDomainRequest*) disableDomainRequest
{
VodDisableDomainExecutor* excutor = [[VodDisableDomainExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:disableDomainRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDisableDomainResponse* response = [[VodDisableDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"disableDomainResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)disableDomainAsyncWithRequest:(VodDisableDomainRequest*) disableDomainRequest
                       completionHandler:(void(^)(int statusCode,VodDisableDomainResponse* _Nullable disableDomainResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDisableDomainExecutor* excutor = [[VodDisableDomainExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:disableDomainRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDisableDomainResponse* response = [[VodDisableDomainResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}

/**
deleteQualityDetectionTemplate sync request
@param deleteQualityDetectionTemplateRequest request param
@return key `statusCode` http request status code type is int
            `dataResult` the http request response data  type is NSData
            `requestError` the request error type is NSError
            `deleteQualityDetectionTemplateResponse` the request response data model
*/
-(NSDictionary*) deleteQualityDetectionTemplateSyncWithRequest:(VodDeleteQualityDetectionTemplateRequest*) deleteQualityDetectionTemplateRequest
{
VodDeleteQualityDetectionTemplateExecutor* excutor = [[VodDeleteQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    NSDictionary* responseResult = [excutor executeSync:deleteQualityDetectionTemplateRequest];
    if(responseResult)
    {
        NSData * resultData = [[responseResult objectForKey:@"dataResult"] copy];
        if(resultData)
        {
            NSMutableDictionary* result = [[NSMutableDictionary alloc]initWithDictionary:responseResult];
            
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteQualityDetectionTemplateResponse* response = [[VodDeleteQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        [result setValue:response forKey:@"deleteQualityDetectionTemplateResponse"];
                        return result;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
    }
    return responseResult;
}


-(void)deleteQualityDetectionTemplateAsyncWithRequest:(VodDeleteQualityDetectionTemplateRequest*) deleteQualityDetectionTemplateRequest
                       completionHandler:(void(^)(int statusCode,VodDeleteQualityDetectionTemplateResponse* _Nullable deleteQualityDetectionTemplateResponse, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
VodDeleteQualityDetectionTemplateExecutor* excutor = [[VodDeleteQualityDetectionTemplateExecutor alloc] initWithJDCloudClient:self];
    [excutor executeAsync:deleteQualityDetectionTemplateRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        if(!error&&responseData)
        {
            NSData * resultData = [responseData copy];
            NSError *jsonError;
            NSDictionary* allKeys = [NSJSONSerialization JSONObjectWithData:resultData options:0 error:&jsonError];
            if(!jsonError&& allKeys)
            {
                @try {
                    VodDeleteQualityDetectionTemplateResponse* response = [[VodDeleteQualityDetectionTemplateResponse alloc]initWithDic:allKeys];
                    if(response)
                    {
                        completionHandler(statusCode,response,responseData,error);
                        return;
                    }
                } @catch (NSException *exception) {
                    if([GlobalConfig isDebug]){
                        NSLog(@"json serialize response data error,info is %@",exception.reason);
                    }
                }
            }
        }
        completionHandler(statusCode,nil,responseData,error);
    }];
}


 /**
 vod common sync request
 @param  jdcloudDataRequest request param
 @return key `statusCode` http request status code type is int
             `dataResult` the http request response data  type is NSData
             `requestError` the request error type is NSError
 */
 -(NSDictionary*) vodCommonSyncWithRequest:(JDCloudDataRequest*) jdcloudDataRequest
                                                   url:(NSString*) url
                                                method:(NSString*) method{
    CommonExecutor* excutor = [[CommonExecutor alloc] initWithJDCloudClient:self url:url method:method];
    NSDictionary* responseResult = [excutor executeDataSync:jdcloudDataRequest];
    return responseResult;
}

-(void)vodCommonAsyncWithRequest:(JDCloudDataRequest*) jdcloudDataRequest
                                         url:(NSString*) url
                                      method:(NSString*) method
                           completionHandler:(void(^)(int statusCode, NSData* _Nullable responseData,NSError * _Nullable error))completionHandler
{
     CommonExecutor* excutor = [[CommonExecutor alloc] initWithJDCloudClient:self url:url method:method];
    
    [excutor executeDataAsync:jdcloudDataRequest completionHandler:^(int statusCode, NSData * _Nullable responseData, NSError * _Nullable error) {
        completionHandler(statusCode,responseData,error);
    }];
} 

@end
